import { EnumDataType } from "@/config/config";

export function pxScale(val: number, unit: string = "px"): any {
  const result = val;
  if (unit) {
    return result + unit;
  }

  return result;
}
export async function getJson(url: string) {
  if (!url) return;

  return await fetch(url).then((res) => {
    return res.json();
  });
}

/**
 * 判断数据类型
 */
export function dataType(data: Date) {
  const type = Object.prototype.toString.call(data);

  switch (type) {
    case "[object String]":
      return EnumDataType.string;
    case "[object Number]":
      return EnumDataType.number;
    case "[object Boolean]":
      return EnumDataType.boolean;
    case "[object Undefined]":
      return EnumDataType.undefined;
    case "[object Null]":
      return EnumDataType.null;
    case "[object Object]":
      return EnumDataType.object;
    case "[object Function]":
      return EnumDataType.function;
    case "[object Array]":
      return EnumDataType.array;
    case "[object Date]":
      return EnumDataType.date;
    case "[object RegExp]":
      return EnumDataType.regExp;
    default:
      return false;
  }
}

/**
 * 位数补零
 * @param data
 * @param num 总位数 默认2
 */
export function supplyZero(data: string | number, num = 2): string {
  //  转 字符串 方便后续计算
  let _data = data.toString().trim();
  const _len = _data.length; //  计算字符串长度

  //  如果字符串长度已经超出, 则直接返回
  if (_len >= num) return _data;

  //  不足的情况下进行 补蛋
  let zeroStr = "";
  for (let i = 0; i < num - _len; i++) {
    zeroStr += "0";
  }

  return zeroStr + _data;
}

/**
 * 处理日期显示格式
 * @param format 分隔符
 * @param ...args 数据集合
 */
export function timeFormat(format: string = "-", ...args: string[]) {
  const _str = args.reduce((prev, _s) => {
    return (prev += format);
  }, "");

  const reg = new RegExp("\\" + format + "$");
  return _str.replace(reg, "");
}

/**
 * 判断图片是否可以被加载
 * @param url 图片访问地址
 */
export function loadImage(url: "") {
  return new Promise((resolve, reject) => {
    const image = new Image();
    (image as any).url = url;

    image.onload = () => {
      resolve(url);
    };

    image.onerror = () => {
      resolve("加载失败");
    };
  });
}

/**
 * 批量判断图片是否添加成功
 */
// export function moreLoadImage() {

// }

/* 文字省略，并给出文字是否满足省略条件的符号 - 利用标识实现后续操作 */
export function textOmit(str: string = "", len: number): any[] {
  let flag = false;
  let text = str;
  //  判断是否需要进行省略
  if (str !== undefined && str.length > len) {
    text = str.slice(0, len) + "...";
    flag = true;
  }

  return [text, flag];
}

//  创建时间列表
export function createYearList(len = 10) {
  const yearList: string[] = [];
  const curYear = new Date().getFullYear();

  while (len--) {
    yearList.push((curYear - len).toString());
  }

  return yearList.reverse();
}
/* 5min 自动刷新大屏 */
export function refreshPage() {
  const delay = 5 * 3600 * 1000;
  // const delay = 5 * 1000;

  const trobbleEvent = debounce(delay);

  // 自己执行
  trobbleEvent();

  //  监听鼠标事件
  document.body.addEventListener("mousemove", trobbleEvent, false);
  //  监听点击事件
  document.body.addEventListener("keydown", trobbleEvent, false);

  //  防抖
  function debounce(delay: any) {
    let time: any = null;
    return function (...args: any[]) {
      //  清除上一次的， 重新开始
      if (time) clearTimeout(time);

      time = setTimeout(() => {
        //  清除定时器
        clearTimeout(time);
        time = null;

        //  移除事件监听
        document.body.removeEventListener("mousemove", trobbleEvent, false);
        document.body.removeEventListener("keydown", trobbleEvent, false); // 滞后1s

        //  重置
        location.reload();
      }, delay);
    };
  }
}

/* 
千分制
@param num 要格式化的数字
@returns 格式化后的数字字符串
 */
export function formatNumber(num: number | string = 0): string {
  const parts = num.toString().split(".");
  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  return parts.join(".");
}

/* 
  处理日期格式
  @param date 日期对象
  @param format 分隔符
*/
export function formatDate(date: any = new Date(), format: string = 'yyyy-MM-dd') {
  let time: any = {};
  time.year = date.getFullYear().toString();
  time.month = supplyZero(date.getMonth() + 1);
  time.day = supplyZero(date.getDate());
  time.hour = supplyZero(date.getHours());
  time.minute = supplyZero(date.getMinutes());
  time.second = supplyZero(date.getSeconds());

  return format
  .replace('yyyy', time.year)
  .replace('MM', time.month)
  .replace('dd', time.day)
  .replace('hh', time.hour)
  .replace('mm', time.minute)
  .replace('ss', time.second);
}

//  生成随机数组队列
export function randomQueue(arr: any[] = []) {
  arr.sort((a, b) => {
    return Math.random() - 0.5;
  });
}

/**
 * 根据给定的数组和分割数，计算出比数组中最大数还要大一点的数
 *
 * @param arr 数组，包含需要比较的数字
 * @param split 分割数，用于计算最终结果的基准
 * @returns 返回比数组中最大数大一点的数
 */
export function compitedMax(arr: any = [], split: number = 5): number {
  // 找出数组中的最大值
  const max: any = Math.max(...arr);
  let result: any = 0;

  // 如果最大值小于等于分割数，直接返回分割数
  if (max <= split) {
    result = split;
  } else {
    //  保证数组总是比最大数大一点
    const count = parseInt(max / split + "");
    result = (count + 1) * split;
  }

  // 返回计算结果
  return result;
}

/**
 * 截取指定数组的子数组
 *
 * @param data - 待处理的数组，默认为空数组
 * @param start - 子数组的起始索引，默认为0
 * @param end - 子数组的结束索引（不包括该索引处的元素），默认为6
 * @returns 返回指定范围内的子数组
 */
export function slcieData(
  data: any = [],
  start: number = 0,
  end: number = 6
): any[] {
  return data.slice(start, end);
}


/**
 * 生成指定长度的随机字符串
 * 主要用于生成唯一的标识符或密码等
 * 
 * @param len {number} 字符串的长度，默认为32
 *        允许用户不传入参数时使用默认长度
 * @returns {string} 生成的随机字符串
 */
export function randomString(len: number = 16) {
  // 定义可用字符集，避免容易混淆的字符，如'0'、'O'、'o'、'1'、'I'、'l'
  var t = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678",
    a = t.length,
    n = "";

  // 循环生成随机字符串，长度为e
  for (let i = 0; i < len; i++) {
    // 每次循环中，随机选择字符集中的一个字符，添加到结果字符串n中
    n += t.charAt(Math.floor(Math.random() * a));
  }

  // 返回生成的随机字符串
  return n;
}
